#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
文本生成器模块主入口
整合报告模板管理和报告生成功能
"""

import os
import json
import logging
import datetime
from typing import Dict, Any, List, Optional, Union
from pathlib import Path

# 设置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
)
logger = logging.getLogger(__name__)


# 动态导入避免循环依赖
from .report_template_manager import ReportTemplateManager
from .report_generator import ReportGenerator


class ReportGenerationError(Exception):
    """
    报告生成相关异常
    """
    pass


class TextGeneratorModule:
    """
    文本生成器模块
    提供完整的报告生成、模板管理和文本处理功能
    """
    
    def __init__(self, 
                 templates_dir: str = None,
                 output_dir: str = None):
        """
        初始化文本生成器模块
        
        Args:
            templates_dir: 模板目录
            output_dir: 输出目录
        """
        # 模块名称
        self.module_name = "TextGeneratorModule"
        
        # 初始化时间
        self.initialized_at = datetime.datetime.now()
        
        # 配置模板目录
        if templates_dir:
            self._templates_dir = templates_dir
        else:
            # 默认模板目录
            self._templates_dir = os.path.join(
                os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
                "data", "templates"
            )
        
        # 配置输出目录
        if output_dir:
            self._output_dir = output_dir
        else:
            # 默认输出目录
            self._output_dir = os.path.join(
                os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
                "output", "reports"
            )
        
        # 确保目录存在
        os.makedirs(self._templates_dir, exist_ok=True)
        os.makedirs(self._output_dir, exist_ok=True)
        
        # 初始化模板管理器
        self._template_manager = ReportTemplateManager(
            templates_dir=self._templates_dir
        )
        
        # 初始化报告生成器
        self._report_generator = ReportGenerator(
            template_manager=self._template_manager
        )
        
        logger.info(f"文本生成器模块初始化完成")
        logger.info(f"  - 模板目录: {self._templates_dir}")
        logger.info(f"  - 输出目录: {self._output_dir}")
    
    def generate_report(self, 
                       analysis_result: Dict[str, Any],
                       template_name: str = None,
                       output_format: str = "markdown") -> str:
        """
        生成报告
        
        Args:
            analysis_result: 分析结果数据
            template_name: 模板名称
            output_format: 输出格式
            
        Returns:
            str: 报告内容
        """
        try:
            # 验证分析结果
            validation = self._report_generator.validate_report_data(analysis_result)
            if not validation['valid']:
                logger.warning(f"报告数据验证警告: {validation['warnings']}")
            
            # 生成报告
            report_content = self._report_generator.generate_report(
                analysis_result=analysis_result,
                template_name=template_name,
                output_format=output_format
            )
            
            return report_content
            
        except Exception as e:
            logger.error(f"生成报告失败: {str(e)}")
            raise ReportGenerationError(f"生成报告失败: {str(e)}")
    
    def save_report(self, 
                   report_content: str,
                   output_path: str = None,
                   output_format: str = "markdown") -> str:
        """
        保存报告到文件
        
        Args:
            report_content: 报告内容
            output_path: 输出路径，如果为None则自动生成
            output_format: 输出格式
            
        Returns:
            str: 保存的文件路径
        """
        try:
            # 自动生成输出路径
            if not output_path:
                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
                filename = f"report_{timestamp}"
                output_path = os.path.join(self._output_dir, filename)
            
            # 确保路径包含目录
            if not os.path.dirname(output_path):
                output_path = os.path.join(self._output_dir, output_path)
            
            # 保存报告
            saved_path = self._report_generator.save_report(
                report_content=report_content,
                output_path=output_path,
                output_format=output_format
            )
            
            return saved_path
            
        except Exception as e:
            logger.error(f"保存报告失败: {str(e)}")
            raise ReportGenerationError(f"保存报告失败: {str(e)}")
    
    def generate_and_save_report(self, 
                                analysis_result: Dict[str, Any],
                                output_path: str = None,
                                template_name: str = None,
                                output_format: str = "markdown") -> str:
        """
        生成并保存报告
        
        Args:
            analysis_result: 分析结果数据
            output_path: 输出路径
            template_name: 模板名称
            output_format: 输出格式
            
        Returns:
            str: 保存的文件路径
        """
        try:
            # 生成报告
            report_content = self.generate_report(
                analysis_result=analysis_result,
                template_name=template_name,
                output_format=output_format
            )
            
            # 保存报告
            saved_path = self.save_report(
                report_content=report_content,
                output_path=output_path,
                output_format=output_format
            )
            
            return saved_path
            
        except Exception as e:
            logger.error(f"生成并保存报告失败: {str(e)}")
            raise ReportGenerationError(f"生成并保存报告失败: {str(e)}")
    
    def create_summary_report(self, 
                             analysis_result: Dict[str, Any],
                             output_path: str = None,
                             output_format: str = "markdown") -> str:
        """
        创建摘要报告（使用简洁模板）
        
        Args:
            analysis_result: 分析结果数据
            output_path: 输出路径
            output_format: 输出格式
            
        Returns:
            str: 报告内容（如果output_path为None）或保存的路径
        """
        report_content = self._report_generator.create_summary_report(
            analysis_result=analysis_result,
            output_format=output_format
        )
        
        if output_path is not None:
            return self.save_report(report_content, output_path, output_format)
        
        return report_content
    
    def create_detailed_report(self, 
                              analysis_result: Dict[str, Any],
                              output_path: str = None,
                              output_format: str = "markdown") -> str:
        """
        创建详细报告（使用标准模板）
        
        Args:
            analysis_result: 分析结果数据
            output_path: 输出路径
            output_format: 输出格式
            
        Returns:
            str: 报告内容（如果output_path为None）或保存的路径
        """
        report_content = self._report_generator.create_detailed_report(
            analysis_result=analysis_result,
            output_format=output_format
        )
        
        if output_path is not None:
            return self.save_report(report_content, output_path, output_format)
        
        return report_content
    
    def create_html_report(self, 
                          analysis_result: Dict[str, Any],
                          output_path: str = None) -> str:
        """
        创建HTML格式报告
        
        Args:
            analysis_result: 分析结果数据
            output_path: 输出路径
            
        Returns:
            str: 报告内容（如果output_path为None）或保存的路径
        """
        report_content = self._report_generator.create_html_report(
            analysis_result=analysis_result
        )
        
        if output_path is not None:
            return self.save_report(report_content, output_path, "html")
        
        return report_content
    
    def validate_analysis_data(self, analysis_result: Dict[str, Any]) -> Dict[str, Any]:
        """
        验证分析结果数据格式
        
        Args:
            analysis_result: 分析结果数据
            
        Returns:
            Dict[str, Any]: 验证结果
        """
        return self._report_generator.validate_report_data(analysis_result)
    
    def get_available_templates(self) -> List[Dict[str, Any]]:
        """
        获取可用模板列表
        
        Returns:
            List[Dict[str, Any]]: 模板信息列表
        """
        return self._template_manager.list_templates()
    
    def create_template(self, 
                       template_name: str,
                       description: str,
                       sections: List[Dict[str, Any]],
                       output_formats: List[str] = None) -> bool:
        """
        创建新模板
        
        Args:
            template_name: 模板名称
            description: 模板描述
            sections: 模板章节列表
            output_formats: 支持的输出格式
            
        Returns:
            bool: 是否创建成功
        """
        return self._template_manager.create_template(
            template_name=template_name,
            description=description,
            sections=sections,
            output_formats=output_formats
        )
    
    def update_template(self, 
                       template_name: str,
                       description: str = None,
                       sections: List[Dict[str, Any]] = None,
                       output_formats: List[str] = None) -> bool:
        """
        更新模板
        
        Args:
            template_name: 模板名称
            description: 模板描述
            sections: 模板章节列表
            output_formats: 支持的输出格式
            
        Returns:
            bool: 是否更新成功
        """
        return self._template_manager.update_template(
            template_name=template_name,
            description=description,
            sections=sections,
            output_formats=output_formats
        )
    
    def delete_template(self, template_name: str) -> bool:
        """
        删除模板
        
        Args:
            template_name: 模板名称
            
        Returns:
            bool: 是否删除成功
        """
        return self._template_manager.delete_template(template_name)
    
    def get_template_variables(self, template_name: str) -> List[str]:
        """
        获取模板变量
        
        Args:
            template_name: 模板名称
            
        Returns:
            List[str]: 变量列表
        """
        return self._template_manager.extract_template_variables(template_name)
    
    def set_default_template(self, template_name: str) -> bool:
        """
        设置默认模板
        
        Args:
            template_name: 模板名称
            
        Returns:
            bool: 是否设置成功
        """
        return self._template_manager.set_default_template(template_name)
    
    def get_default_template(self) -> str:
        """
        获取默认模板名称
        
        Returns:
            str: 默认模板名称
        """
        return self._template_manager.get_default_template_name()
    
    def get_module_info(self) -> Dict[str, Any]:
        """
        获取模块信息
        
        Returns:
            Dict[str, Any]: 模块信息
        """
        return {
            "module_name": self.module_name,
            "initialized_at": self.initialized_at.isoformat(),
            "templates_dir": self._templates_dir,
            "output_dir": self._output_dir,
            "available_templates": len(self.get_available_templates()),
            "default_template": self.get_default_template()
        }
    
    def validate_template(self, template: Dict[str, Any]) -> Dict[str, Any]:
        """
        验证模板格式
        
        Args:
            template: 模板数据
            
        Returns:
            Dict[str, Any]: 验证结果
        """
        return self._template_manager.validate_template(template)
    
    def convert_markdown_to_html(self, markdown_content: str) -> str:
        """
        将Markdown转换为HTML
        
        Args:
            markdown_content: Markdown内容
            
        Returns:
            str: HTML内容
        """
        return self._report_generator.markdown_to_html(markdown_content)
    
    def process_batch_reports(self, 
                             analysis_results: List[Dict[str, Any]],
                             template_name: str = None,
                             output_format: str = "markdown",
                             batch_output_dir: str = None) -> List[str]:
        """
        批量处理报告
        
        Args:
            analysis_results: 分析结果列表
            template_name: 模板名称
            output_format: 输出格式
            batch_output_dir: 批处理输出目录
            
        Returns:
            List[str]: 生成的报告文件路径列表
        """
        try:
            # 设置批处理输出目录
            if batch_output_dir:
                current_output_dir = batch_output_dir
            else:
                # 使用时间戳创建批处理目录
                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
                current_output_dir = os.path.join(self._output_dir, f"batch_{timestamp}")
            
            os.makedirs(current_output_dir, exist_ok=True)
            
            # 处理每个分析结果
            generated_files = []
            for idx, analysis_result in enumerate(analysis_results):
                try:
                    # 生成文件名
                    video_id = analysis_result.get("video_id", f"video_{idx}")
                    filename = f"report_{video_id}"
                    output_path = os.path.join(current_output_dir, filename)
                    
                    # 生成并保存报告
                    saved_path = self.generate_and_save_report(
                        analysis_result=analysis_result,
                        output_path=output_path,
                        template_name=template_name,
                        output_format=output_format
                    )
                    
                    generated_files.append(saved_path)
                    logger.info(f"批处理报告 {idx+1}/{len(analysis_results)} 完成: {saved_path}")
                    
                except Exception as e:
                    logger.error(f"处理报告 {idx} 失败: {str(e)}")
                    continue
            
            logger.info(f"批处理完成，成功生成 {len(generated_files)}/{len(analysis_results)} 个报告")
            return generated_files
            
        except Exception as e:
            logger.error(f"批处理报告失败: {str(e)}")
            raise ReportGenerationError(f"批处理报告失败: {str(e)}")


# 全局实例
_text_generator_instance = None


def get_text_generator(templates_dir: str = None, 
                      output_dir: str = None) -> TextGeneratorModule:
    """
    获取文本生成器模块实例（单例模式）
    
    Args:
        templates_dir: 模板目录
        output_dir: 输出目录
        
    Returns:
        TextGeneratorModule: 文本生成器模块实例
    """
    global _text_generator_instance
    
    if _text_generator_instance is None:
        _text_generator_instance = TextGeneratorModule(
            templates_dir=templates_dir,
            output_dir=output_dir
        )
    
    # 如果提供了新的目录，更新配置
    if templates_dir and templates_dir != _text_generator_instance._templates_dir:
        logger.warning("文本生成器实例已存在，无法更新模板目录")
    
    if output_dir and output_dir != _text_generator_instance._output_dir:
        logger.warning("文本生成器实例已存在，无法更新输出目录")
    
    return _text_generator_instance


def initialize_text_generator(templates_dir: str = None, 
                             output_dir: str = None) -> TextGeneratorModule:
    """
    初始化文本生成器模块
    
    Args:
        templates_dir: 模板目录
        output_dir: 输出目录
        
    Returns:
        TextGeneratorModule: 文本生成器模块实例
    """
    global _text_generator_instance
    
    # 创建新实例
    _text_generator_instance = TextGeneratorModule(
        templates_dir=templates_dir,
        output_dir=output_dir
    )
    
    return _text_generator_instance


# 使用示例
if __name__ == '__main__':
    try:
        print("文本生成器模块测试中...")
        
        # 创建模块实例
        text_generator = get_text_generator()
        
        # 获取模块信息
        module_info = text_generator.get_module_info()
        print("\n模块信息:")
        for key, value in module_info.items():
            print(f"  - {key}: {value}")
        
        # 获取可用模板
        templates = text_generator.get_available_templates()
        print("\n可用模板:")
        for template in templates:
            print(f"  - {template['name']}: {template['description']}")
            print(f"    支持格式: {', '.join(template['output_formats'])}")
        
        # 创建测试数据
        test_analysis_result = {
            "video_id": "test_dy_video_001",
            "video_title": "抖音生活视频示例",
            "overall_summary": "这是一个展示日常生活的短视频，内容积极向上，充满生活气息。",
            "category_results": [
                {
                    "category_name": "生活方式",
                    "result": "是",
                    "confidence": 0.96,
                    "reasoning": "视频中展示了丰富的日常生活场景和元素，包括家居环境、日常活动等。",
                    "keywords": ["生活", "日常", "家居", "休闲"]
                },
                {
                    "category_name": "美食",
                    "result": "是",
                    "confidence": 0.82,
                    "reasoning": "视频中出现了食物准备和享用的场景，属于美食类内容。",
                    "keywords": ["烹饪", "美食", "食材", "餐厅"]
                },
                {
                    "category_name": "旅行",
                    "result": "否",
                    "confidence": 0.91,
                    "reasoning": "未发现明显的旅行场景、地标或交通工具等旅行相关元素。",
                    "keywords": []
                },
                {
                    "category_name": "运动健身",
                    "result": "否",
                    "confidence": 0.87,
                    "reasoning": "未发现体育锻炼、健身器材或运动相关活动。",
                    "keywords": []
                },
                {
                    "category_name": "教育",
                    "result": "否",
                    "confidence": 0.94,
                    "reasoning": "内容以展示和分享为主，未包含系统性的知识传授或教学内容。",
                    "keywords": []
                },
                {
                    "category_name": "娱乐",
                    "result": "是",
                    "confidence": 0.78,
                    "reasoning": "视频风格轻松愉快，具有娱乐性和观赏性。",
                    "keywords": ["娱乐", "休闲", "放松"]
                },
                {
                    "category_name": "科技",
                    "result": "否",
                    "confidence": 0.95,
                    "reasoning": "未发现科技产品、技术演示或相关内容。",
                    "keywords": []
                }
            ],
            "scene_description": "室内家居环境，明亮温馨的客厅场景。",
            "key_elements": [
                {"name": "沙发", "confidence": 0.93},
                {"name": "茶几", "confidence": 0.89},
                {"name": "电视", "confidence": 0.85},
                {"name": "餐桌", "confidence": 0.82},
                {"name": "食物", "confidence": 0.80}
            ],
            "main_colors": ["暖黄色", "米白色", "原木色", "浅蓝色"],
            "total_frames": 5,
            "analyzed_frames": 5,
            "sentiment_analysis": {
                "label": "积极",
                "confidence": 0.92
            },
            "extracted_keywords": [
                ("生活", 0.97),
                ("日常", 0.91),
                ("美食", 0.86),
                ("家居", 0.82),
                ("休闲", 0.79),
                ("舒适", 0.75),
                ("温馨", 0.73),
                ("享受", 0.70),
                ("放松", 0.68),
                ("愉悦", 0.65)
            ],
            "topic_analysis": [
                {
                    "topic": "家居生活",
                    "keywords": ["沙发", "电视", "茶几", "温馨"],
                    "relevance": 0.94
                },
                {
                    "topic": "美食享受",
                    "keywords": ["美食", "烹饪", "食材", "享用"],
                    "relevance": 0.87
                },
                {
                    "topic": "休闲时光",
                    "keywords": ["休闲", "放松", "愉悦", "舒适"],
                    "relevance": 0.83
                }
            ],
            "text_summary": "这是一个展示温馨家居生活和美食享受的短视频，整体氛围轻松愉快，内容积极向上。",
            "content_summary": "视频主要涵盖生活方式和美食两个类目，整体基调温馨舒适，展现了高品质的日常生活状态。",
            "audience_suggestions": "适合对生活品质有追求、喜爱美食和家居生活的观众群体，年龄段主要集中在20-40岁。",
            "optimization_suggestions": "建议增加互动元素，如提问、引导评论等，同时可以考虑添加更多细节展示，增强内容的真实感和代入感。"
        }
        
        # 验证数据
        validation = text_generator.validate_analysis_data(test_analysis_result)
        print(f"\n数据验证结果: {'有效' if validation['valid'] else '有警告'}")
        if validation['warnings']:
            for warning in validation['warnings']:
                print(f"  - {warning}")
        
        # 生成并保存各类报告
        print("\n开始生成报告...")
        
        # 简洁报告
        concise_path = text_generator.create_summary_report(
            analysis_result=test_analysis_result,
            output_path="test_summary_report"
        )
        print(f"简洁报告已生成并保存: {concise_path}")
        
        # 详细报告
        detailed_path = text_generator.create_detailed_report(
            analysis_result=test_analysis_result,
            output_path="test_detailed_report"
        )
        print(f"详细报告已生成并保存: {detailed_path}")
        
        # HTML报告
        html_path = text_generator.create_html_report(
            analysis_result=test_analysis_result,
            output_path="test_html_report.html"
        )
        print(f"HTML报告已生成并保存: {html_path}")
        
        print("\n文本生成器模块测试完成!")
        print("\nT4 文本生成器模块已成功实现:")
        print("  1. 报告模板管理器 - 支持模板的创建、管理和验证")
        print("  2. 报告生成器 - 支持多种格式的报告渲染")
        print("  3. 多种报告格式 - 支持Markdown、HTML、纯文本")
        print("  4. 批量处理能力 - 支持多视频报告批量生成")
        print("  5. 完整的错误处理和日志记录")
        
    except Exception as e:
        print(f"测试失败: {str(e)}")